package org.dtrd.modules.flup.service.impl;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.dtrd.modules.flup.entity.bean.FlupTemplateProjectRelationDetail;
import org.dtrd.modules.flup.entity.bean.FlupTemplateProjectRelationListInfo;
import org.dtrd.modules.flup.entity.po.DtrdRlFlupTemplateProject;
import org.dtrd.modules.flup.entity.request.TemplateProjectRelationRequest;
import org.dtrd.modules.flup.mapper.DtrdRlFlupTemplateProjectMapper;
import org.dtrd.modules.flup.service.IDtrdRlFlupTemplateProjectService;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;


/**
 * <p>
 * 复诊模版和复诊模版内容关系表 服务实现类
 * </p>
 *
 * @author QR
 * @since 2021-12-21
 */
@DS("multi-datasource1")
@Service
@Slf4j
public class DtrdRlFlupTemplateProjectServiceImpl extends ServiceImpl<DtrdRlFlupTemplateProjectMapper, DtrdRlFlupTemplateProject> implements IDtrdRlFlupTemplateProjectService {

    @Override
    public List<Integer> getProjectIds(Integer templateId) {
        LambdaQueryWrapper<DtrdRlFlupTemplateProject> queryWrapper = baseQueryWrapper();
        queryWrapper.eq(DtrdRlFlupTemplateProject::getTemplateId, templateId);
        List<DtrdRlFlupTemplateProject> list = this.list(queryWrapper);
        return Optional.ofNullable(list)
                .map(poList -> poList.stream().map(DtrdRlFlupTemplateProject::getTemplateProjectId).collect(Collectors.toList()))
                .orElse(null);
    }

    @Override
    public int clearTemplate(Integer templateId) {
        return baseMapper.clearTemplate(templateId);
    }

    @Override
    public boolean hasFlupTemplate(Integer templateId, List<Integer> projectIds) {
        LambdaQueryWrapper<DtrdRlFlupTemplateProject> queryWrapper = baseQueryWrapper()
                .notIn(DtrdRlFlupTemplateProject::getTemplateId, templateId);
        // 查找出其他 templateId 的全部复诊模版组合
        List<DtrdRlFlupTemplateProject> poList = this.list(queryWrapper);
        // 根据 templateId 分组
        Map<Integer, List<DtrdRlFlupTemplateProject>> map = poList.stream()
                .collect(Collectors.groupingBy(DtrdRlFlupTemplateProject::getTemplateId));
        Set<Integer> keySet = map.keySet();
        for (Integer key : keySet) {
            List<DtrdRlFlupTemplateProject> list = map.get(key);
            List<Integer> poProjectIds = list.stream()
                    .map(DtrdRlFlupTemplateProject::getTemplateProjectId).collect(Collectors.toList());
            // 如果 某个模板包含的项目id 和传入 projectIds 相同，那么两个模版重复，返回true
            // (模版项目个数不同 && 组合不同) 即不相等
            if (poProjectIds.size() == projectIds.size() && poProjectIds.containsAll(projectIds)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public List<FlupTemplateProjectRelationListInfo> getRlFlupTemplateProjectList(TemplateProjectRelationRequest request) {
        LambdaQueryWrapper<DtrdRlFlupTemplateProject> queryWrapper = baseQueryWrapper();
        List<DtrdRlFlupTemplateProject> poList = list(queryWrapper);
        List<FlupTemplateProjectRelationListInfo> dtoList = new ArrayList<>(poList.size());
        if (!poList.isEmpty()) {
            dtoList = poList.stream().map(FlupTemplateProjectRelationListInfo::new).collect(Collectors.toList());
        }
        return dtoList;
    }

    @Override
    public FlupTemplateProjectRelationDetail getRlFlupTemplateProject(Integer dataId) {
        DtrdRlFlupTemplateProject dtrdRlFlupTemplateProject = getById(dataId);
        return Optional.ofNullable(dtrdRlFlupTemplateProject)
                        .map(po -> new FlupTemplateProjectRelationDetail().parseFromPo(po))
                        .orElse(null);
    }

    @Override
    public boolean saveOrUpdateRlFlupTemplateProject(FlupTemplateProjectRelationDetail dto) {
        DtrdRlFlupTemplateProject dtrdRlFlupTemplateProject = new DtrdRlFlupTemplateProject();
        if(dto.getDataId() == null){
            dtrdRlFlupTemplateProject = dtrdRlFlupTemplateProject.init();
        }
        dtrdRlFlupTemplateProject.parseFromDto(dto);
        return saveOrUpdate(dtrdRlFlupTemplateProject);
    }

    @Override
    public boolean removeRlFlupTemplateProject(Integer dataId) {
        return removeById(dataId);
    }

    @Override
    public boolean hasLinkTemplate(Integer projectId) {
        LambdaQueryWrapper<DtrdRlFlupTemplateProject> wrapper = Wrappers.lambdaQuery(DtrdRlFlupTemplateProject.class)
                .eq(DtrdRlFlupTemplateProject::getTemplateProjectId, projectId);
        int count = count(wrapper);
        log.info("模版项目: {} 记录数量: {}", projectId, count);
        return count > 0;
    }

    private LambdaQueryWrapper<DtrdRlFlupTemplateProject> baseQueryWrapper() {
        return Wrappers.lambdaQuery(DtrdRlFlupTemplateProject.class)
                        .eq(DtrdRlFlupTemplateProject::getIsDel, 0);
    }

    private LambdaUpdateWrapper<DtrdRlFlupTemplateProject> baseUpdateWrapper() {
        return Wrappers.lambdaUpdate(DtrdRlFlupTemplateProject.class)
                        .eq(DtrdRlFlupTemplateProject::getIsDel, 0);
    }
}
